MacHack 1999

home *** CD-ROM | disk | FTP | other *** search

/ MacHack 1999 / MacHack 1999.toast / The Hacks / X-Ray / X-Ray INIT Source / qdPatches.c < prev next >

Wrap

Text File | 1999-06-08 | 87.8 KB | 1,862 lines | [TEXT/CWIE]

// Copyright (C) 1999 Eric Roccasecca. All rights reserved. #include "X_Ray_Priv.h" UniversalProcPtr gOldStdLine, gStdLineUPP = nil, gOldStdRect, gStdRectUPP = nil, gOldStdOval, gStdOvalUPP = nil, gOldStdRgn, gStdRgnUPP = nil, gOldStdRRect, gStdRRectUPP = nil, gOldStdPoly, gStdPolyUPP = nil, gOldStdArc, gStdArcUPP = nil, gOldStdText, gStdTextUPP = nil, gOldStdBits, gStdBitsUPP = nil, gOldCopyBits, gCopyBitsUPP = nil, gOldCopyMask, gCopyMaskUPP = nil, gOldCopyDeepMask, gCopyDeepMaskUPP = nil, gOldScrollRect, gScrollRectUPP = nil; // used to share port info during any drawing X-Ray intercepts RgnHandle qd_curClipRgn, qd_copyBitsToSelfClipRgn; GrafPtr qd_origPort; CGrafPtr qd_origGWorld; GDHandle qd_origGDH; CQDProcs qd_curCQDProcs, *qd_underBufferCQDProcs = nil; ThemeDrawingState qd_curDrawState; RGBColor qd_foreColor, qd_backColor; FontInfo qd_fInfo; X_Ray_AppRecHandle qd_curApp; UInt8 qd_Hilite; // globals used for determining X-Ray draws Point qd_startPoint, qd_endPoint; Rect qd_drawingRect, qd_curDrawingRect; RgnHandle qd_drawingRgn, qd_curDrawRgn; X_Ray_WindowHandle qd_transWin, qd_intersection, qd_curIntersection, qd_tempWin; // never rely on this accross calls Boolean qd_bitMapOnScreen; PixMapHandle qd_contPMap, qd_mixPMap, qd_underPMap, qd_curUnderPMap, qd_maskPMap; short gUpdatePassDebug; OSErr qd_err; Boolean gDoingUpdateAboveDebug = false; short X_RayDrawLevel = 0; extern Boolean gProcessManagerIsRunning; extern RgnHandle gIntersectCurPortVisRgn, gIntersectCurTransVisRgn; pascal void X_Ray_StdLine (Point endPoint); pascal void X_Ray_StdArc (GrafVerb verb, const Rect *theRect, short startAngle, short arcAngle); pascal void X_Ray_StdRRect (GrafVerb verb, const Rect *theRect, short ovalWidth, short ovalHeight); pascal void X_Ray_StdText (short count, const void *textAddr, Point *numer, Point *denom); pascal void X_Ray_StdRect (GrafVerb verb, const Rect *theRect); pascal void X_Ray_StdPoly (GrafVerb verb, PolyHandle poly); pascal void X_Ray_StdOval (GrafVerb verb, const Rect *theRect); pascal void X_Ray_StdOval (GrafVerb verb, const Rect *theRect); pascal void X_Ray_StdRgn (GrafVerb verb, RgnHandle rgn); pascal void X_Ray_StdBits (const BitMap *srcBits, const Rect *srcRect, const Rect *dstRect, short mode, RgnHandle maskRgn); pascal void X_Ray_CopyBits (const BitMap *srcBits, const BitMap *dstBits, const Rect *srcRect, const Rect *dstRect, short mode, RgnHandle maskRgn); pascal void X_Ray_CopyMask (const BitMap *srcBits, const BitMap *maskBits, const BitMap *dstBits, const Rect *srcRect, const Rect *maskRect, const Rect *dstRect); pascal void X_Ray_CopyDeepMask (const BitMap *srcBits, const BitMap *maskBits, const BitMap *dstBits, const Rect *srcRect, const Rect *maskRect, const Rect *dstRect, short mode, RgnHandle maskRgn); pascal void X_Ray_ScrollRect (const Rect *theRect, short dh, short dv, RgnHandle updateRgn); void SetupUnderBufferGWorld (GWorldPtr curUnderBuffer, GrafPtr sourcePort); void UnsetupUnderBufferGWorld (GWorldPtr curUnderBuffer, GrafPtr sourcePort); void UpdateTransparentWindows (Boolean normal); #define UpdateTransparentWindows_Normal() UpdateTransparentWindows(true) #define UpdateTransparentWindows_Special() UpdateTransparentWindows(false) Boolean InitInternalQuickDraw (void) { // intialize global regions qd_drawingRgn = NewRgn(); qd_curClipRgn = NewRgn(); qd_curDrawRgn = NewRgn(); qd_copyBitsToSelfClipRgn = NewRgn(); gIntersectCurPortVisRgn = NewRgn(); gIntersectCurTransVisRgn = NewRgn(); // QuickDraw PATCHES // Apply patch to StdLine gOldStdLine = NGetTrapAddress (_StdLine, ToolTrap); gStdLineUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdLine, kStdLineProcInfo, kPowerPCISA); if (gStdLineUPP) { NSetTrapAddress (gStdLineUPP, _StdLine, ToolTrap); } else return false; // Apply patch to StdText gOldStdText = NGetTrapAddress (_StdText, ToolTrap); gStdTextUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdText, kStdTextProcInfo, kPowerPCISA); if (gStdTextUPP) { NSetTrapAddress (gStdTextUPP, _StdText, ToolTrap); } else return false; // Apply patch to StdRect gOldStdRect = NGetTrapAddress (_StdRect, ToolTrap); gStdRectUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdRect, kStdRectProcInfo, kPowerPCISA); if (gStdRectUPP) { NSetTrapAddress (gStdRectUPP, _StdRect, ToolTrap); } else return false; // Apply patch to StdRRect gOldStdRRect = NGetTrapAddress (_StdRRect, ToolTrap); gStdRRectUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdRRect, kStdRRectProcInfo, kPowerPCISA); if (gStdRRectUPP) { NSetTrapAddress (gStdRRectUPP, _StdRRect, ToolTrap); } else return false; // Apply patch to StdArc gOldStdArc = NGetTrapAddress (_StdArc, ToolTrap); gStdArcUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdArc, kStdArcProcInfo, kPowerPCISA); if (gStdArcUPP) { NSetTrapAddress (gStdArcUPP, _StdArc, ToolTrap); } else return false; // Apply patch to StdPoly gOldStdPoly = NGetTrapAddress (_StdPoly, ToolTrap); gStdPolyUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdPoly, kStdPolyProcInfo, kPowerPCISA); if (gStdPolyUPP) { NSetTrapAddress (gStdPolyUPP, _StdPoly, ToolTrap); } else return false; // Apply patch to StdOval gOldStdOval = NGetTrapAddress (_StdOval, ToolTrap); gStdOvalUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdOval, kStdOvalProcInfo, kPowerPCISA); if (gStdOvalUPP) { NSetTrapAddress (gStdOvalUPP, _StdOval, ToolTrap); } else return false; // Apply patch to StdRgn gOldStdRgn = NGetTrapAddress (_StdRgn, ToolTrap); gStdRgnUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdRgn, kStdRgnProcInfo, kPowerPCISA); if (gStdRgnUPP) { NSetTrapAddress (gStdRgnUPP, _StdRgn, ToolTrap); } else return false; // Apply patch to StdBits gOldStdBits = NGetTrapAddress (_StdBits, ToolTrap); gStdBitsUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_StdBits, kStdBitsProcInfo, kPowerPCISA); if (gStdBitsUPP) { NSetTrapAddress (gStdBitsUPP, _StdBits, ToolTrap); } else return false; // Apply patch to CopyBits gOldCopyBits = NGetTrapAddress (_CopyBits, ToolTrap); gCopyBitsUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_CopyBits, kCopyBitsProcInfo, kPowerPCISA); if (gCopyBitsUPP) { NSetTrapAddress (gCopyBitsUPP, _CopyBits, ToolTrap); } else return false; // Apply patch to CopyDeepMask gOldCopyDeepMask = NGetTrapAddress (_CopyDeepMask, ToolTrap); gCopyDeepMaskUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_CopyDeepMask, kCopyDeepMaskProcInfo, kPowerPCISA); if (gCopyDeepMaskUPP) { NSetTrapAddress (gCopyDeepMaskUPP, _CopyDeepMask, ToolTrap); } else return false; // Apply patch to CopyMask gOldCopyMask = NGetTrapAddress (_CopyMask, ToolTrap); gCopyMaskUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_CopyMask, kCopyMaskProcInfo, kPowerPCISA); if (gCopyMaskUPP) { NSetTrapAddress (gCopyMaskUPP, _CopyMask, ToolTrap); } else return false; // Apply patch to ScrollRect gOldScrollRect = NGetTrapAddress (_ScrollRect, ToolTrap); gScrollRectUPP = NewRoutineDescriptor ((ProcPtr)X_Ray_ScrollRect, kScrollRectProcInfo, kPowerPCISA); if (gScrollRectUPP) NSetTrapAddress (gScrollRectUPP, _ScrollRect, ToolTrap); else return false; return true; } pascal void X_Ray_StdLine (Point endPoint) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); GetThemeDrawingState (&qd_curDrawState); qd_startPoint = qd_origPort->pnLoc; qd_endPoint = endPoint; Pt2Rect (qd_startPoint, qd_endPoint, &qd_drawingRect); InsetRect (&qd_drawingRect, -1, -1); RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region LocalToGlobal (&qd_startPoint); LocalToGlobal (&qd_endPoint); qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdLine in transparent"); //CallUniversalProc (gOldStdLine, kStdLineProcInfo, endPoint); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_origPort->clipRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); CallUniversalProc (gOldStdLine, kStdLineProcInfo, endPoint); UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdLine intersection"); //CallUniversalProc (gOldStdLine, kStdLineProcInfo, endPoint); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); GlobalToLocal (&qd_startPoint); GlobalToLocal (&qd_endPoint); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort MoveTo (qd_startPoint.h, qd_startPoint.v); SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); CallUniversalProc (gOldStdLine, kStdLineProcInfo, qd_endPoint); UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); LocalToGlobal (&qd_startPoint); LocalToGlobal (&qd_endPoint); } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); CallUniversalProc (gOldStdLine, kStdLineProcInfo, endPoint); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldStdLine, kStdLineProcInfo, endPoint); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdLine, kStdLineProcInfo, endPoint); } pascal void X_Ray_StdRect (GrafVerb verb, const Rect *theRect) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); qd_Hilite = LMGetHiliteMode(); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *theRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdRect in transparent"); //CallUniversalProc (gOldStdRect, kStdRectProcInfo, verb, theRect); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_drawingRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRect, kStdRectProcInfo, verb, theRect); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //CallUniversalProc (gOldStdRect, kStdRectProcInfo, verb, theRect); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRect, kStdRectProcInfo, verb, &qd_drawingRect); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRect, kStdRectProcInfo, verb, theRect); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldStdRect, kStdRectProcInfo, verb, theRect); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdRect, kStdRectProcInfo, verb, theRect); } pascal void X_Ray_StdOval (GrafVerb verb, const Rect *theRect) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); qd_Hilite = LMGetHiliteMode(); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *theRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdOval in transparent"); //CallUniversalProc (gOldStdOval, kStdOvalProcInfo, verb, theRect); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_drawingRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdOval, kStdOvalProcInfo, verb, theRect); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdOval intersection"); //CallUniversalProc (gOldStdOval, kStdOvalProcInfo, verb, theRect); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdOval, kStdOvalProcInfo, verb, &qd_drawingRect); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdOval, kStdOvalProcInfo, verb, theRect); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window under buffers from back to front } else // no need to redirect this draw CallUniversalProc (gOldStdOval, kStdOvalProcInfo, verb, theRect); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdOval, kStdOvalProcInfo, verb, theRect); } pascal void X_Ray_StdRRect (GrafVerb verb, const Rect *theRect, short ovalWidth, short ovalHeight) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); qd_Hilite = LMGetHiliteMode(); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *theRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdRRect in transparent"); //CallUniversalProc (gOldStdRRect, kStdRRectProcInfo, verb, theRect, ovalWidth, ovalHeight); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_origPort->clipRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRRect, kStdRRectProcInfo, verb, theRect, ovalWidth, ovalHeight); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdRRect intersection"); //CallUniversalProc (gOldStdRRect, kStdRRectProcInfo, verb, theRect, ovalWidth, ovalHeight); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRRect, kStdRRectProcInfo, verb, &qd_drawingRect, ovalWidth, ovalHeight); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRRect, kStdRRectProcInfo, verb, theRect, ovalWidth, ovalHeight); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldStdRRect, kStdRRectProcInfo, verb, theRect, ovalWidth, ovalHeight); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdRRect, kStdRRectProcInfo, verb, theRect, ovalWidth, ovalHeight); } pascal void X_Ray_StdArc (GrafVerb verb, const Rect *theRect, short startAngle, short arcAngle) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); qd_Hilite = LMGetHiliteMode(); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *theRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdArc in transparent"); //CallUniversalProc (gOldStdArc, kStdArcProcInfo, verb, theRect, startAngle, arcAngle); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_origPort->clipRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdArc, kStdArcProcInfo, verb, theRect, startAngle, arcAngle); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdArc intersection"); //CallUniversalProc (gOldStdArc, kStdArcProcInfo, verb, theRect, startAngle, arcAngle); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdArc, kStdArcProcInfo, verb, &qd_drawingRect, startAngle, arcAngle); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdArc, kStdArcProcInfo, verb, theRect, startAngle, arcAngle); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldStdArc, kStdArcProcInfo, verb, theRect, startAngle, arcAngle); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdArc, kStdArcProcInfo, verb, theRect, startAngle, arcAngle); } pascal void X_Ray_StdPoly (GrafVerb verb, PolyHandle poly) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); qd_Hilite = LMGetHiliteMode(); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = (*poly)->polyBBox; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalPoly (poly); // globalize the polygon qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdPoly in transparent"); //CallUniversalProc (gOldStdPoly, kStdPolyProcInfo, verb, poly); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort X_Ray_GlobalToLocalPoly (poly); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_origPort->clipRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdPoly, kStdPolyProcInfo, verb, poly); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdPoly intersection"); //CallUniversalProc (gOldStdPoly, kStdPolyProcInfo, verb, poly); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalPoly (poly); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdPoly, kStdPolyProcInfo, verb, poly); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalPoly (poly); } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region X_Ray_GlobalToLocalPoly (poly); SetClip (qd_drawingRgn); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdPoly, kStdPolyProcInfo, verb, poly); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw { X_Ray_GlobalToLocalPoly (poly); CallUniversalProc (gOldStdPoly, kStdPolyProcInfo, verb, poly); } DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdPoly, kStdPolyProcInfo, verb, poly); } pascal void X_Ray_StdRgn (GrafVerb verb, RgnHandle rgn) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); qd_Hilite = LMGetHiliteMode(); GetThemeDrawingState (&qd_curDrawState); CopyRgn (rgn, qd_drawingRgn); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdRgn in transparent"); //CallUniversalProc (gOldStdRgn, kStdRgnProcInfo, verb, rgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_origPort->clipRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRgn, kStdRgnProcInfo, verb, rgn); UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdRgn intersection"); //CallUniversalProc (gOldStdRgn, kStdRgnProcInfo, verb, rgn); //if (!(qd_Hilite & 0x80)) // DebugStr ("\philite intersection region"); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRgn, kStdRgnProcInfo, verb, qd_curDrawRgn); UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); LMSetHiliteMode (qd_Hilite); CallUniversalProc (gOldStdRgn, kStdRgnProcInfo, verb, rgn); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldStdRgn, kStdRgnProcInfo, verb, rgn); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdRgn, kStdRgnProcInfo, verb, rgn); } pascal void X_Ray_StdBits (const BitMap *srcBits, const Rect *srcRect, const Rect *dstRect, short mode, RgnHandle maskRgn) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *dstRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn if (maskRgn) SectRgn (maskRgn, qd_drawingRgn, qd_drawingRgn); // clip to the specified maskRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdBits in transparent"); //CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, dstRect, mode, maskRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_drawingRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, dstRect, mode, qd_drawingRgn); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdBits intersection"); //CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, dstRect, mode, maskRgn); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, &qd_drawingRect, mode, qd_curDrawRgn); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, dstRect, mode, maskRgn); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Special(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, dstRect, mode, maskRgn); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, dstRect, mode, maskRgn); } // CallUniversalProc (gOldCopyBits, kCopyBitsProcInfo, srcBits, dstBits, srcRect, dstRect, mode, maskRgn); pascal void X_Ray_CopyBits (const BitMap *srcBits, const BitMap *dstBits, const Rect *srcRect, const Rect *dstRect, short mode, RgnHandle maskRgn) { unsigned long dummy; if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *dstRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn if (maskRgn) SectRgn (maskRgn, qd_drawingRgn, qd_drawingRgn); // clip to the specified maskRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pCopyBits in transparent"); //CallUniversalProc (gOldStdBits, kStdBitsProcInfo, srcBits, srcRect, dstRect, mode, maskRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_drawingRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); CallUniversalProc (gOldCopyBits, kCopyBitsProcInfo, srcBits, (BitMap*)*qd_contPMap, srcRect, dstRect, mode, qd_drawingRgn); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { if (srcBits == dstBits) // copies to self need extra help to prevent copying the contents of the trans wins SetEmptyRgn (qd_copyBitsToSelfClipRgn); //DebugStr ("\pCopyBits intersection"); //CallUniversalProc (gOldCopyBits, kCopyBitsProcInfo, srcBits, dstBits, srcRect, dstRect, mode, maskRgn); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); if (srcBits == dstBits) // help with copy to self UnionRgn (qd_curDrawRgn, qd_copyBitsToSelfClipRgn, qd_copyBitsToSelfClipRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); CallUniversalProc (gOldCopyBits, kCopyBitsProcInfo, srcBits, (BitMap*)*qd_underPMap, srcRect, &qd_drawingRect, mode, qd_curDrawRgn); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region if (srcBits == dstBits) // help with copy to self { // this assures that the copy doesn't copy what is in any intersecting trans wins // the Mac OS 8 Finder does this when scrolling a window instead of calling ScrollRect() X_Ray_GlobalToLocalRgn (qd_copyBitsToSelfClipRgn); DiffRgn (qd_curDrawRgn, qd_copyBitsToSelfClipRgn, qd_curDrawRgn); InvalRgn (qd_copyBitsToSelfClipRgn); // force an update after the CopyBits OffsetRgn (qd_copyBitsToSelfClipRgn, dstRect->left - srcRect->left, dstRect->top - srcRect->top); DiffRgn (qd_curDrawRgn, qd_copyBitsToSelfClipRgn, qd_curDrawRgn); InvalRgn (qd_copyBitsToSelfClipRgn); // force an update after the CopyBits } SetClip (qd_drawingRgn); CallUniversalProc (gOldCopyBits, kCopyBitsProcInfo, srcBits, dstBits, srcRect, dstRect, mode, maskRgn); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Special(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldCopyBits, kCopyBitsProcInfo, srcBits, dstBits, srcRect, dstRect, mode, maskRgn); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldCopyBits, kCopyBitsProcInfo, srcBits, dstBits, srcRect, dstRect, mode, maskRgn); } pascal void X_Ray_CopyDeepMask (const BitMap *srcBits, const BitMap *maskBits, const BitMap *dstBits, const Rect *srcRect, const Rect *maskRect, const Rect *dstRect, short mode, RgnHandle maskRgn) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *dstRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn if (maskRgn) SectRgn (maskRgn, qd_drawingRgn, qd_drawingRgn); // clip to the specified maskRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pCopyDeepMask in transparent"); //CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect, mode, maskRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_drawingRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, srcBits, maskBits, (BitMap*)*qd_contPMap, srcRect, maskRect, dstRect, mode, qd_drawingRgn); // do the draw! UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pCopyDeepMask intersection"); //CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect, mode, maskRgn); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, srcBits, maskBits, (BitMap*)*qd_underPMap, srcRect, maskRect, &qd_drawingRect, mode, qd_curDrawRgn); // do the draw! UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect, mode, maskRgn); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Special(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect, mode, maskRgn); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect, mode, maskRgn); } pascal void X_Ray_CopyMask (const BitMap *srcBits, const BitMap *maskBits, const BitMap *dstBits, const Rect *srcRect, const Rect *maskRect, const Rect *dstRect) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); GetThemeDrawingState (&qd_curDrawState); qd_drawingRect = *dstRect; // save current draw rect RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region X_Ray_LocalToGlobalRect (&qd_drawingRect); // globalize draw rect qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pCopyMask in transparent"); //CallUniversalProc (gOldCopyMask, kCopyMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_drawingRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); CallUniversalProc (gOldCopyMask, kCopyMaskProcInfo, srcBits, maskBits, (BitMap*)*qd_contPMap, srcRect, maskRect, dstRect); UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pCopyMask intersection"); //CallUniversalProc (gOldCopyMask, kCopyMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); X_Ray_GlobalToLocalRect (&qd_drawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); CallUniversalProc (gOldCopyMask, kCopyMaskProcInfo, srcBits, maskBits, (BitMap*)*qd_underPMap, srcRect, maskRect, &qd_drawingRect); UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); X_Ray_LocalToGlobalRect (&qd_drawingRect); // and set up for the next possible draw } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); CallUniversalProc (gOldCopyMask, kCopyMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Special(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldCopyMask, kCopyMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldCopyMask, kCopyMaskProcInfo, srcBits, maskBits, dstBits, srcRect, maskRect, dstRect); } pascal void X_Ray_ScrollRect (const Rect *theRect, short dh, short dv, RgnHandle updateRgn) { RgnHandle curVisRgn, addedSectRgns; if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); RectRgn (qd_drawingRgn, theRect); X_Ray_LocalToGlobalRgn (qd_drawingRgn); qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); if (qd_intersection) { // the rect to be scrolled does intersect at least one transWin curVisRgn = NewRgn(); addedSectRgns = NewRgn(); CopyRgn (qd_origPort->visRgn, curVisRgn); // save current port's visRgn qd_curIntersection = qd_intersection; while (qd_curIntersection) // walk forward through all trans wins to determine who all intersects the scroll rect { SetPort ((*qd_curIntersection)->theWindow); // to get proper screen coordinates CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); UnionRgn (addedSectRgns, qd_curDrawRgn, addedSectRgns); // add together all intersecting trans window visRgns qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); X_Ray_GlobalToLocalRgn (addedSectRgns); DiffRgn (qd_origPort->visRgn, addedSectRgns, qd_origPort->visRgn); // now subtract the intersecting transVisRgns from the cur ports visRgn // this tricks QD into thinking it shouldn't scroll info in under the window // and QD thinks it can't copy data from under the window as well } CallUniversalProc (gOldScrollRect, kScrollRectProcInfo, theRect, dh, dv, updateRgn); if (qd_intersection) { if (updateRgn) UnionRgn (addedSectRgns, updateRgn, updateRgn); // add to the calculated updateRgn InvalRgn (addedSectRgns); // and force an update event for good masure CopyRgn (curVisRgn, qd_origPort->visRgn); // restore current port's visRgn DisposeRgn (addedSectRgns); DisposeRgn (curVisRgn); } X_RayDrawLevel--; } else CallUniversalProc (gOldScrollRect, kScrollRectProcInfo, theRect, dh, dv, updateRgn); } pascal void X_Ray_StdText (short count, const void *textAddr, Point *numer, Point *denom) { if ((X_RayDrawLevel == 0) && gProcessManagerIsRunning) { X_RayDrawLevel++; GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); GetThemeDrawingState (&qd_curDrawState); qd_startPoint = qd_origPort->pnLoc; qd_endPoint = qd_startPoint; GetFontInfo (&qd_fInfo); // ADD // Should StdTxMeas be used instead of TextWidth? TextWidth seems to work ok. qd_endPoint.h += TextWidth (textAddr, 0, count); qd_endPoint.v -= qd_fInfo.ascent; Pt2Rect (qd_endPoint, qd_startPoint, &qd_drawingRect); qd_drawingRect.bottom += qd_fInfo.descent + qd_fInfo.leading; // make sure g's and j's don't get clipped InsetRect (&qd_drawingRect, -2, -2); RectRgn (qd_drawingRgn, &qd_drawingRect); // determine a region that bounds draw SectRgn (qd_origPort->clipRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current clipRgn SectRgn (qd_origPort->visRgn, qd_drawingRgn, qd_drawingRgn); // clip draw region to the current visRgn X_Ray_LocalToGlobalRgn (qd_drawingRgn); // globalize draw region LocalToGlobal (&qd_startPoint); qd_transWin = X_Ray_GetWindowRec (qd_origPort); // set up for analyzing how to draw qd_intersection = PortDoesIntersect (qd_origPort, qd_drawingRgn); // see if qd_origPort is on screen and intersects at least one transparent port and qd_drawingRgn if (qd_transWin || qd_intersection) { if (qd_transWin) // current port is a transparent window { //DebugStr ("\pStdText in transparent"); //CallUniversalProc (gOldStdText, kStdTextProcInfo, count, textAddr, numer, denom); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // set to local coords of qd_origPort SetGWorld ((*qd_transWin)->contentBuffer, nil); SetClip (qd_origPort->clipRgn); SetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // set up contentBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); CallUniversalProc (gOldStdText, kStdTextProcInfo, count, textAddr, numer, denom); UnlockPixels (qd_contPMap); UnsetupUnderBufferGWorld ((*qd_transWin)->contentBuffer, qd_origPort); // clear certain fields especially ones that are hazardous when persistent UnionRgn (qd_drawingRgn, (*qd_transWin)->transparentUpdateRgn, (*qd_transWin)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld (qd_origGWorld, qd_origGDH); } // draw wasn't to a transparent window, but the draw does intersect a transparent window else if (qd_intersection) { //DebugStr ("\pStdText intersection"); //CallUniversalProc (gOldStdText, kStdTextProcInfo, count, textAddr, numer, denom); // walk transparent chain forward from qd_intersection and draw in underbuffers where draw intersects visRgns of owner ports // this is a one level deep intersection, any more than this are handled when transparentUpdateRgns are updated qd_curIntersection = qd_intersection; while (qd_curIntersection && !EmptyRgn(qd_drawingRgn)) // draw in all transparent under buffers where intersection occurs at one level { SetPort ((*qd_curIntersection)->theWindow); CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_drawingRgn, qd_curDrawRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this portion of draw from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); GlobalToLocal (&qd_startPoint); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post notice the underbuffer has changed and window needs update SetGWorld ((*qd_curIntersection)->underBuffer, nil); SetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // set up underBuffer graphics port here: copy foreColor, backColor, etc. of qd_origPort MoveTo (qd_startPoint.h, qd_startPoint.v); SetClip (qd_curDrawRgn); // clip draw to the current local draw limits qd_underPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); LockPixels (qd_underPMap); CallUniversalProc (gOldStdText, kStdTextProcInfo, count, textAddr, numer, denom); UnlockPixels (qd_underPMap); UnsetupUnderBufferGWorld ((*qd_curIntersection)->underBuffer, qd_origPort); // clear certain fields that are hazardous when persistent SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment SetPort ((*qd_curIntersection)->theWindow); LocalToGlobal (&qd_startPoint); } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort (qd_origPort); GetClip (qd_curClipRgn); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // limit drawing to whatever is left of drawing region SetClip (qd_drawingRgn); CallUniversalProc (gOldStdText, kStdTextProcInfo, count, textAddr, numer, denom); SetClip (qd_curClipRgn); } UpdateTransparentWindows_Normal(); // updates transparent window list from back to front looking for transparentUpdateRgns } else // no need to redirect this draw CallUniversalProc (gOldStdText, kStdTextProcInfo, count, textAddr, numer, denom); DisposeThemeDrawingState (qd_curDrawState); X_RayDrawLevel--; } else CallUniversalProc (gOldStdText, kStdTextProcInfo, count, textAddr, numer, denom); } // DRAWING UTILITIES // upon entry the current port is curUnderBuffer // this synchronizes the original dest port with the current underbuffer as best as it can void SetupUnderBufferGWorld (GWorldPtr curUnderBuffer, GrafPtr sourcePort) { SetThemeDrawingState (qd_curDrawState, false); if (((CGrafPtr)sourcePort)->portVersion&0xC000) // sourcePort is color { if (sourcePort->grafProcs) { qd_underBufferCQDProcs = curUnderBuffer->grafProcs; // save any preexisting CQDProcs for the underbuffer curUnderBuffer->grafProcs = ((CGrafPtr)sourcePort)->grafProcs; // copy the sourcePorts CQDProcs } ((GrafVars*)*(curUnderBuffer->grafVars))->rgbHiliteColor = ((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->rgbHiliteColor; ((GrafVars*)*(curUnderBuffer->grafVars))->rgbOpColor = ((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->rgbOpColor; ((GrafVars*)*(curUnderBuffer->grafVars))->pmFgIndex = ((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmFgIndex; ((GrafVars*)*(curUnderBuffer->grafVars))->pmBkIndex = ((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmBkIndex; ((GrafVars*)*(curUnderBuffer->grafVars))->pmFlags = ((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmFlags; SetHandleSize (((GrafVars*)*(curUnderBuffer->grafVars))->pmFgColor, GetHandleSize(((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmFgColor)); BlockMoveData (*((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmFgColor, *((GrafVars*)*(curUnderBuffer->grafVars))->pmFgColor, GetHandleSize(((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmFgColor)); SetHandleSize (((GrafVars*)*(curUnderBuffer->grafVars))->pmBkColor, GetHandleSize(((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmBkColor)); BlockMoveData (*((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmBkColor, *((GrafVars*)*(curUnderBuffer->grafVars))->pmBkColor, GetHandleSize(((GrafVars*)*(((CGrafPtr)sourcePort)->grafVars))->pmBkColor)); curUnderBuffer->chExtra = ((CGrafPtr)sourcePort)->chExtra; curUnderBuffer->pnLocHFrac = ((CGrafPtr)sourcePort)->pnLocHFrac; qd_foreColor = ((CGrafPtr)sourcePort)->rgbFgColor; qd_backColor = ((CGrafPtr)sourcePort)->rgbBkColor; RGBForeColor (&qd_foreColor); RGBBackColor (&qd_backColor); CopyPixPat (((CGrafPtr)sourcePort)->bkPixPat, curUnderBuffer->bkPixPat); CopyPixPat (((CGrafPtr)sourcePort)->fillPixPat, curUnderBuffer->fillPixPat); CopyPixPat (((CGrafPtr)sourcePort)->pnPixPat, curUnderBuffer->pnPixPat); } else // sourcePort is BW { // ** need to do BW to color conversion of patterns ** // ** what would be the best way to do this? // really a shame all ports aren't color // need to do BW to color conversion of grafProcs since grafProcs differ from color to BW // this maye be extreme voodoo if (sourcePort->grafProcs) { qd_underBufferCQDProcs = curUnderBuffer->grafProcs; qd_curCQDProcs.textProc = sourcePort->grafProcs->textProc; qd_curCQDProcs.lineProc = sourcePort->grafProcs->lineProc; qd_curCQDProcs.rectProc = sourcePort->grafProcs->rectProc; qd_curCQDProcs.rRectProc = sourcePort->grafProcs->rRectProc; qd_curCQDProcs.ovalProc = sourcePort->grafProcs->ovalProc; qd_curCQDProcs.arcProc = sourcePort->grafProcs->arcProc; qd_curCQDProcs.polyProc = sourcePort->grafProcs->polyProc; qd_curCQDProcs.rgnProc = sourcePort->grafProcs->rgnProc; qd_curCQDProcs.bitsProc = sourcePort->grafProcs->bitsProc; qd_curCQDProcs.commentProc = sourcePort->grafProcs->commentProc; qd_curCQDProcs.txMeasProc = sourcePort->grafProcs->txMeasProc; qd_curCQDProcs.getPicProc = sourcePort->grafProcs->getPicProc; qd_curCQDProcs.putPicProc = sourcePort->grafProcs->putPicProc; // nil un-used portions of grafProcs qd_curCQDProcs.opcodeProc = nil; qd_curCQDProcs.newProc1 = nil; qd_curCQDProcs.glyphsProc = ((CQDProcs*)sourcePort->grafProcs)->glyphsProc; qd_curCQDProcs.printerStatusProc = ((CQDProcs*)sourcePort->grafProcs)->printerStatusProc; qd_curCQDProcs.newProc4 = nil; qd_curCQDProcs.newProc5 = nil; qd_curCQDProcs.newProc6 = nil; curUnderBuffer->grafProcs = &qd_curCQDProcs; } curUnderBuffer->fgColor = sourcePort->fgColor; curUnderBuffer->bkColor = sourcePort->bkColor; } // Pen Metrics //curUnderBuffer->pnLoc = sourcePort->pnLoc; // this is wrong, needs to be made global from sourcePort and then local to curUnderBuffer //curUnderBuffer->pnSize = sourcePort->pnSize; // don't know why this is commented out //curUnderBuffer->pnMode = sourcePort->pnMode; // don't know why this is commented out //curUnderBuffer->pnVis = sourcePort->pnVis; // don't know why this is commented out // Font Metrics curUnderBuffer->txFont = sourcePort->txFont; curUnderBuffer->txFace = sourcePort->txFace; curUnderBuffer->txMode = sourcePort->txMode; curUnderBuffer->txSize = sourcePort->txSize; curUnderBuffer->spExtra = sourcePort->spExtra; //curUnderBuffer->colrBit = sourcePort->colrBit; // don't know why this is commented out //curUnderBuffer->patStretch = sourcePort->patStretch; // don't know why this is commented out PortChanged ((GrafPtr)curUnderBuffer); } // upon entry the current port is curUnderBuffer // ok this doesn't do much for now, but it is here in case it is needed for more than just qdprocs void UnsetupUnderBufferGWorld (GWorldPtr curUnderBuffer, GrafPtr sourcePort) { if (((CGrafPtr)sourcePort)->portVersion&0xC000) // sourcePort is color { } else // curPort is BW { } PenMode (srcCopy); ForeColor (blackColor); BackColor (whiteColor); curUnderBuffer->grafProcs = qd_underBufferCQDProcs; PortChanged ((GrafPtr)curUnderBuffer); } // updates transparent windows that have non empty transparentUpdateRgn // normal = true -- will call CopyDeepMask // normal = false -- will call CopyDeepMask via patch void UpdateTransparentWindows (Boolean normal) { GetPort (&qd_origPort); GetGWorld (&qd_origGWorld, &qd_origGDH); if (qd_transWin == nil) qd_transWin = qd_intersection; while (qd_transWin) { if (!EmptyRgn ((*qd_transWin)->transparentUpdateRgn)) { SetPort ((*qd_transWin)->theWindow); // set port to the on screen port (window) so the correct coordinate system will be in effect // these are both currently local to qd_transWin qd_drawingRect = (*(*qd_transWin)->transparentUpdateRgn)->rgnBBox; CopyRgn ((*qd_transWin)->transparentUpdateRgn, qd_drawingRgn); SetEmptyRgn ((*qd_transWin)->transparentUpdateRgn); // remove this transparent update event GetClip (qd_curClipRgn); // because the real on-screen windows for transparent windows get updated from off screen, the real clipRgns can be "ignored" during updates SetClip (qd_drawingRgn); // Fill the mixBuffer // first copy in the underBuffer SetGWorld ((*qd_transWin)->mixBuffer, nil); ForeColor (blackColor); BackColor (whiteColor); qd_mixPMap = GetGWorldPixMap ((*qd_transWin)->mixBuffer); LockPixels (qd_mixPMap); qd_underPMap = GetGWorldPixMap ((*qd_transWin)->underBuffer); LockPixels (qd_underPMap); if (normal) CopyBits ((BitMap*)*qd_underPMap, (BitMap*)*qd_mixPMap, &qd_drawingRect, &qd_drawingRect, srcCopy, qd_drawingRgn); else CallUniversalProc (gOldStdBits, kStdBitsProcInfo, (BitMap*)*qd_underPMap, &qd_drawingRect, &qd_drawingRect, srcCopy, qd_drawingRgn); // do the draw! UnlockPixels (qd_mixPMap); UnlockPixels (qd_underPMap); // next copy in the contentBuffer //SetupMaskBuffer (&qd_drawingRect, (*qd_transWin)->transparency); // match maskBuffer to current dimensions of draw, this is pretty slow RGBBackColor (&(*qd_transWin)->clearColor); // either it will be white, or the clear color qd_mixPMap = GetGWorldPixMap ((*qd_transWin)->mixBuffer); LockPixels (qd_mixPMap); qd_maskPMap = GetGWorldPixMap ((*qd_transWin)->maskBuffer); LockPixels (qd_maskPMap); qd_contPMap = GetGWorldPixMap ((*qd_transWin)->contentBuffer); LockPixels (qd_contPMap); // !!! this is actually what makes a window transparent (or clear), the call to CopyDeepMask when mixing the under buffer and content buffer in the mix buffer if (normal) CopyDeepMask ((BitMap*)*qd_contPMap, (BitMap*)*qd_maskPMap, (BitMap*)*qd_mixPMap, &qd_drawingRect, &qd_drawingRect, &qd_drawingRect, srcCopy, qd_drawingRgn); //CopyDeepMask ((BitMap*)*qd_contPMap, (BitMap*)*qd_maskPMap, (BitMap*)*qd_mixPMap, &qd_drawingRect, &qd_drawingRect, &qd_drawingRect, ((*qd_transWin)->windowKind&kIsClear) ? transparent : srcCopy, qd_drawingRgn); else CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, (BitMap*)*qd_contPMap, (BitMap*)*qd_maskPMap, (BitMap*)*qd_mixPMap, &qd_drawingRect, &qd_drawingRect, &qd_drawingRect, srcCopy, qd_drawingRgn); //CallUniversalProc (gOldCopyDeepMask, kCopyDeepMaskProcInfo, (BitMap*)*qd_contPMap, (BitMap*)*qd_maskPMap, (BitMap*)*qd_mixPMap, &qd_drawingRect, &qd_drawingRect, &qd_drawingRect, ((*qd_transWin)->windowKind&kIsClear) ? transparent : srcCopy, qd_drawingRgn); UnlockPixels (qd_mixPMap); UnlockPixels (qd_maskPMap); UnlockPixels (qd_contPMap); // get ready to update the screen SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment, specifically curDevice SetPort ((*qd_transWin)->theWindow); // set port to the on-screen port so the correct coordinate system will be in effect X_Ray_LocalToGlobalRgn (qd_drawingRgn); qd_curDrawingRect = qd_drawingRect; X_Ray_LocalToGlobalRect (&qd_curDrawingRect); // first update any underbuffers of intersecting transparent windows // walk forward in the window chain from qd_transWin qd_curIntersection = GetNextWindowAbove (qd_transWin); while (qd_curIntersection) { SetPort ((*qd_curIntersection)->theWindow); // set port to the on screen port so the correct coordinate system will be in effect for the underBuffer CopyRgn ((*qd_curIntersection)->theWindow->visRgn, qd_curDrawRgn); X_Ray_LocalToGlobalRgn (qd_curDrawRgn); SectRgn (qd_curDrawRgn, qd_drawingRgn, qd_curDrawRgn); if (!EmptyRgn (qd_curDrawRgn)) // areas overlap? { DiffRgn (qd_drawingRgn, qd_curDrawRgn, qd_drawingRgn); // subtract this draw (in global coordinates) from the overall draw X_Ray_GlobalToLocalRgn (qd_curDrawRgn); // make everything local to the current underbuffer via the coord system of its real on-screen window X_Ray_GlobalToLocalRect (&qd_curDrawingRect); UnionRgn (qd_curDrawRgn, (*qd_curIntersection)->transparentUpdateRgn, (*qd_curIntersection)->transparentUpdateRgn); // post the update for this underBuffer SetGWorld ((*qd_curIntersection)->underBuffer, nil); ForeColor (blackColor); BackColor (whiteColor); qd_curUnderPMap = GetGWorldPixMap ((*qd_curIntersection)->underBuffer); // get ready to do this draw portion LockPixels (qd_curUnderPMap); qd_mixPMap = GetGWorldPixMap ((*qd_transWin)->mixBuffer); LockPixels (qd_mixPMap); ClipRect (&(*qd_curUnderPMap)->bounds); // make sure clip is wide open if (normal) CopyBits ((BitMap*)*qd_mixPMap, (BitMap*)*qd_curUnderPMap, &qd_drawingRect, &qd_curDrawingRect, srcCopy, qd_curDrawRgn); // note the source rect is qd_drawingRect, which is appropriately local to qd_mixPMap else CallUniversalProc (gOldStdBits, kStdBitsProcInfo, (BitMap*)*qd_mixPMap, &qd_drawingRect, &qd_curDrawingRect, srcCopy, qd_curDrawRgn); // note the source rect is qd_drawingRect, which is appropriately local to qd_mixPMap SetGWorld (qd_origGWorld, qd_origGDH); // restore drawing environment, specicfically curDevice SetPort ((*qd_curIntersection)->theWindow); // set port to the on screen port so the correct coordinate system will be in effect for the underBuffer UnlockPixels (qd_curUnderPMap); UnlockPixels (qd_mixPMap); X_Ray_LocalToGlobalRect (&qd_curDrawingRect); } qd_curIntersection = GetNextWindowAbove (qd_curIntersection); } SetPort ((*qd_transWin)->theWindow); // alright, all one level underBuffer intersections have been updated, so finish this update GetForeColor (&qd_foreColor); GetBackColor (&qd_backColor); ForeColor (blackColor); BackColor (whiteColor); X_Ray_GlobalToLocalRgn (qd_drawingRgn); // finish the draw qd_mixPMap = GetGWorldPixMap ((*qd_transWin)->mixBuffer); LockPixels (qd_mixPMap); if (normal) CopyBits ((BitMap*)*qd_mixPMap, &(*qd_transWin)->theWindow->portBits, &qd_drawingRect, &qd_drawingRect, srcCopy, qd_drawingRgn); else CallUniversalProc (gOldStdBits, kStdBitsProcInfo, (BitMap*)*qd_mixPMap, &qd_drawingRect, &qd_drawingRect, srcCopy, qd_drawingRgn); UnlockPixels (qd_mixPMap); // restore theWindow parameters RGBForeColor (&qd_foreColor); RGBBackColor (&qd_backColor); SetClip (qd_curClipRgn); SetPort (qd_origPort); } // walk up the window list one level qd_transWin = GetNextWindowAbove (qd_transWin); } }